"use strict";
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
/*
 * @@file:
 * @@Author: Zhou Mingle <zhoumingle@baidu.com>
 * @@Date: Do not edit
 * @LastEditors: Please set LastEditors
 * @LastEditTime: 2021-03-26 11:35:02
 */
// 一、多态与抽象类
console.log("-----一、多态与抽象类------");
// 1.1 多态：父类定义一个方法不实现，让继承他的子类去实现  每一个子类有想不同 的表现
console.log("------1.1 多态-----");
// 多态属于继承
var Animal = /** @class */ (function () {
    function Animal(n) {
        this.name = n;
    }
    ;
    Animal.prototype.eat = function () {
        console.log("这是Animal类中eat方法，但是这个方法没有被具体实现");
    };
    return Animal;
}());
// 继承Animal1的一个子类
var Dog1 = /** @class */ (function (_super) {
    __extends(Dog1, _super);
    function Dog1(n) {
        return _super.call(this, n) || this;
    }
    ;
    Dog1.prototype.eat = function () {
        console.log(this.name + "\u5403\u8089---\u662FAnimal\u7684\u5B50\u7C7B\uFF0C\u8FD9\u4E2Aeat\u65B9\u6CD5\u5728dog1\u5B50\u7C7B\u4E2D\u5457\u5177\u4F53\u5B9E\u73B0\u4E86");
    };
    return Dog1;
}(Animal));
// 继承Animal1的一个子类
var Cat1 = /** @class */ (function (_super) {
    __extends(Cat1, _super);
    function Cat1(n) {
        return _super.call(this, n) || this;
    }
    ;
    Cat1.prototype.eat = function () {
        console.log(this.name + "\u5403\u8001\u9F20---\u662FAnimal\u7684\u5B50\u7C7B\uFF0C\u8FD9\u4E2Aeat\u65B9\u6CD5\u5728cat1\u5B50\u7C7B\u4E2D\u5457\u5177\u4F53\u5B9E\u73B0\u4E86");
    };
    return Cat1;
}(Animal));
// 创建出两个子类的实例
var dog01 = new Dog1("小黄狗");
var cat01 = new Cat1("小花猫");
dog01.eat();
cat01.eat();
// 1.2 抽象类
console.log("------1.2 抽象类-----");
// typescript中抽象类 ，他是提供其他继承的基类，不能直接被实例化
// 用abstract关键字去定义抽象类和方法，抽象类的抽象方法不包含具体实现并且必须在派生类中实现
// abstract抽象方法只能放在抽象类中
// 抽象类和抽象方法用来定义标准按，标准：animal这个类要求它的子类必须包含eat方法
var Animal2 = /** @class */ (function () {
    function Animal2(n) {
        this.name = n;
    }
    ;
    return Animal2;
}());
// var test01 =new  Animal2() 错误写法，为抽象类无法实例化
var Dog2 = /** @class */ (function (_super) {
    __extends(Dog2, _super);
    function Dog2(n) {
        return _super.call(this, n) || this;
    }
    ;
    Dog2.prototype.eat = function () {
        throw new Error(this.name + "这是一个错误对象的实例被抛出了");
    };
    return Dog2;
}(Animal2));
// 实例化一个抽象类的子类
var dog02 = new Dog2("小黑");
dog02.eat();
